import {defineStore} from 'pinia'
import {ref} from 'vue'
import {APP_CONFIG} from '@/config.js'
import request from '@/utils/request.js'
import {ElMessage} from 'element-plus'
import router from '@/router/index.js'
import {useRoleStore} from './role.js'
import { mockUserData } from '@/mock/userMock.js'

/**
 * @description 管理当前用户的登录状态、用户信息以及认证相关操作
 */
export const useUserStore = defineStore('user', () => {
    const roleStore = useRoleStore()
    
    // 当前登录用户信息
    const user = ref(null)

    // 用户是否已认证
    const isAuthenticated = ref(false)

    // 加载状态
    const loading = ref(false)

    // 更新用户信息和认证状态
    function setUser(userInfo) {
        user.value = userInfo
        isAuthenticated.value = !!userInfo
    }

    // 🎯 核心方法1：获取用户角色
    function getUserRoles() {
        try {
            if (!user.value) return ['USER']; // 默认角色

            if (APP_CONFIG.AUTH_MODE === 'mock') {
                const mockUser = localStorage.getItem('mock_user');
                if (mockUser) {
                    const parsedUser = JSON.parse(mockUser);
                    return parsedUser.roles ? parsedUser.roles : [parsedUser.roleName || 'USER'];
                }
                return [user.value.roleName || 'USER'];
            } else {
                return user.value.roles || [user.value.roleName || 'USER'];
            }
        } catch (error) {
            console.error('获取用户角色失败', error)
            return ['USER']; // 出错返回默认角色
        }
    }

    // 🎯 核心方法2：权限检查（委托给roleStore）
    function hasPermission(permission) {
        return roleStore.hasPermission(user.value, permission)
    }

    // 🎯 核心方法3：获取用户权限
    function getUserPermissions() {
        if (!user.value) return []
        
        // 情况1：直接使用后端返回的权限
        if (user.value.permissions) {
            return user.value.permissions
        }
        
        // 情况2：根据角色计算权限
        return roleStore.getRolePermissions(user.value.roleName)
    }

    function clearAuthData() {
        user.value = null
        isAuthenticated.value = false
        // JWT-Cookie模式不需要清除localStorage，因为token在HttpOnly Cookie中
        if (APP_CONFIG.AUTH_MODE === 'mock') {
            localStorage.removeItem('mock_user')
        }
    }

    /**
     * 处理请求（带降级处理）
     *
     * @description 执行请求函数，当出现404错误时使用模拟数据降级处理
     * @param {Function} requestFn - 请求函数
     * @param {*} fallbackData - 降级使用的模拟数据
     * @returns {Promise<*>} 请求结果或模拟数据
     */
    const handleRequest = async (requestFn, fallbackData) => {
        try {
            return await requestFn()
        } catch (err) {
            // 如果是404，说明没有后端，使用模拟数据
            if (err.message.includes('404')) {
                console.warn('后端接口未找到，使用模拟数据')
                ElMessage({
                    message: '后端服务未启动，使用模拟数据',
                    type: 'warning',
                    duration: 3000
                })
                return fallbackData
            } else {
                throw err
            }
        }
    }

    // 🎯 核心方法4：退出登录
    const logout = async () => {
        user.value = null;
        isAuthenticated.value = false;

        if (APP_CONFIG.AUTH_MODE === 'mock') {
            localStorage.removeItem('mock_user');
        } else if (APP_CONFIG.AUTH_MODE === 'jwt-cookie') {
            try {
                await request.post('/auth/logout');
                ElMessage.success('已退出登录');
            } catch (err) {
                console.error('Logout error', err);
                ElMessage.error('登出失败：' + (err.message || '未知错误'));
            }
        }

        await router.push('/auth/login');
    }

    // 🎯 核心方法5：初始化用户状态
    const initUserState = () => {
        if (APP_CONFIG.AUTH_MODE === 'mock') {
            const mockUser = localStorage.getItem('mock_user');
            if (mockUser) {
                setUser(JSON.parse(mockUser));
            }
        }
        // JWT模式不需要初始化，靠cookie自动认证
    }

    // 🎯 核心方法6：Mock登录 - 独立函数，逻辑清晰
    async function handleMockLogin(credentials) {
        // 根据用户名从 mockUserData 中查找用户
        let mockUser;
        if (credentials && credentials.username) {
            mockUser = mockUserData.find(user => user.username === credentials.username);
        }
        
        // 如果没找到匹配的用户，使用默认的管理员用户
        if (!mockUser) {
            mockUser = mockUserData[1]; // 默认使用管理员用户
        }
        
        // 检查用户状态，如果账户被禁用则阻止登录
        if (mockUser.status !== 1) {
            ElMessage.error('账户已被禁用或不存在');
            return {success: false, error: '账户已被禁用或不存在'};
        }
        
        setUser(mockUser);
        localStorage.setItem('mock_user', JSON.stringify(mockUser));
        ElMessage.success('模拟登录成功');

        return {success: true, message: '登录成功', isMock: true};
    }

    // 🎯 核心方法7：真实登录 - 独立函数，逻辑清晰  
    async function handleRealLogin(credentials) {
        // 1. 调用登录接口
        await request.post('/auth/login', credentials);

        // 2. 获取用户信息（包含权限）
        const userInfo = await request.get('/auth/profile');
        
        // 3. 检查用户状态，如果账户被禁用则阻止登录
        if (userInfo.status !== 1) {
            ElMessage.error('账户已被禁用或不存在');
            return {success: false, error: '账户已被禁用或不存在'};
        }

        // 4. 设置用户状态
        setUser(userInfo);
        ElMessage.success('登录成功');

        return {success: true, message: '登录成功', isMock: false};
    }

    // 用户登录
    const login = async (credentials) => {
        loading.value = true;

        try {
            if (APP_CONFIG.AUTH_MODE === 'mock') {
                // Mock模式：直接设置模拟用户
                return await handleMockLogin(credentials);
            } else {
                // 真实模式：调用登录接口
                return await handleRealLogin(credentials);
            }
        } catch (error) {
            console.error('登录失败:', error);
            ElMessage.error(`登录失败：${error.message || '未知错误'}`);
            return {success: false, error: error.message};
        } finally {
            loading.value = false;
        }
    }

    return {
        // 状态
        user,
        isAuthenticated,
        loading,

        // 方法
        setUser,
        getUserRoles,
        hasPermission,
        getUserPermissions,
        initUserState,
        login,
        logout
    }
})